const char **vec, unsigned int len)
{
char *str;
- struct xenbus_transaction *xbt;
+ xenbus_transaction_t xbt;
int err;
if (shutting_down != SHUTDOWN_INVALID)
unsigned int len)
{
char sysrq_key = '\0';
- struct xenbus_transaction *xbt;
+ xenbus_transaction_t xbt;
int err;
again:
*/
static void connect(struct backend_info *be)
{
- struct xenbus_transaction *xbt;
+ xenbus_transaction_t xbt;
int err;
struct xenbus_device *dev = be->dev;
struct blkfront_info *info)
{
const char *message = NULL;
- struct xenbus_transaction *xbt;
+ xenbus_transaction_t xbt;
int err;
/* Create shared ring, alloc event channel. */
struct netfront_info *info)
{
const char *message;
- struct xenbus_transaction *xbt;
+ xenbus_transaction_t xbt;
int err;
err = xen_net_read_mac(dev, info->mac);
static void connect(struct backend_info *be)
{
- struct xenbus_transaction *xbt;
+ xenbus_transaction_t xbt;
int err;
struct xenbus_device *dev = be->dev;
unsigned long ready = 1;
{
const char *message = NULL;
int err;
- struct xenbus_transaction *xbt;
+ xenbus_transaction_t xbt;
err = setup_tpmring(dev, info);
if (err) {
int xenbus_switch_state(struct xenbus_device *dev,
- struct xenbus_transaction *xbt,
+ xenbus_transaction_t xbt,
XenbusState state)
{
/* We check whether the state is currently set to the given value, and
struct xenbus_dev_transaction {
struct list_head list;
- struct xenbus_transaction *handle;
+ xenbus_transaction_t handle;
};
struct xenbus_dev_data {
}
if (u->u.msg.type == XS_TRANSACTION_START) {
- trans->handle = (struct xenbus_transaction *)
+ trans->handle = (xenbus_transaction_t)
simple_strtoul(reply, NULL, 0);
list_add(&trans->list, &u->transactions);
} else if (u->u.msg.type == XS_TRANSACTION_END) {
}
/* Send message to xs, get kmalloc'ed reply. ERR_PTR() on error. */
-static void *xs_talkv(struct xenbus_transaction *t,
+static void *xs_talkv(xenbus_transaction_t t,
enum xsd_sockmsg_type type,
const struct kvec *iovec,
unsigned int num_vecs,
}
/* Simplified version of xs_talkv: single message. */
-static void *xs_single(struct xenbus_transaction *t,
+static void *xs_single(xenbus_transaction_t t,
enum xsd_sockmsg_type type,
const char *string,
unsigned int *len)
return ret;
}
-char **xenbus_directory(struct xenbus_transaction *t,
+char **xenbus_directory(xenbus_transaction_t t,
const char *dir, const char *node, unsigned int *num)
{
char *strings, *path;
EXPORT_SYMBOL(xenbus_directory);
/* Check if a path exists. Return 1 if it does. */
-int xenbus_exists(struct xenbus_transaction *t,
+int xenbus_exists(xenbus_transaction_t t,
const char *dir, const char *node)
{
char **d;
* Returns a kmalloced value: call free() on it after use.
* len indicates length in bytes.
*/
-void *xenbus_read(struct xenbus_transaction *t,
+void *xenbus_read(xenbus_transaction_t t,
const char *dir, const char *node, unsigned int *len)
{
char *path;
/* Write the value of a single file.
* Returns -err on failure.
*/
-int xenbus_write(struct xenbus_transaction *t,
+int xenbus_write(xenbus_transaction_t t,
const char *dir, const char *node, const char *string)
{
const char *path;
EXPORT_SYMBOL(xenbus_write);
/* Create a new directory. */
-int xenbus_mkdir(struct xenbus_transaction *t,
+int xenbus_mkdir(xenbus_transaction_t t,
const char *dir, const char *node)
{
char *path;
EXPORT_SYMBOL(xenbus_mkdir);
/* Destroy a file or directory (directories must be empty). */
-int xenbus_rm(struct xenbus_transaction *t, const char *dir, const char *node)
+int xenbus_rm(xenbus_transaction_t t, const char *dir, const char *node)
{
char *path;
int ret;
/* Start a transaction: changes by others will not be seen during this
* transaction, and changes will not be visible to others until end.
*/
-struct xenbus_transaction *xenbus_transaction_start(void)
+xenbus_transaction_t xenbus_transaction_start(void)
{
char *id_str;
unsigned long id;
id_str = xs_single(XBT_NULL, XS_TRANSACTION_START, "", NULL);
if (IS_ERR(id_str)) {
up_read(&xs_state.suspend_mutex);
- return (struct xenbus_transaction *)id_str;
+ return (xenbus_transaction_t )id_str;
}
id = simple_strtoul(id_str, NULL, 0);
kfree(id_str);
- return (struct xenbus_transaction *)id;
+ return (xenbus_transaction_t) id;
}
EXPORT_SYMBOL(xenbus_transaction_start);
/* End a transaction.
* If abandon is true, transaction is discarded instead of committed.
*/
-int xenbus_transaction_end(struct xenbus_transaction *t, int abort)
+int xenbus_transaction_end(xenbus_transaction_t t, int abort)
{
char abortstr[2];
int err;
EXPORT_SYMBOL(xenbus_transaction_end);
/* Single read and scanf: returns -errno or num scanned. */
-int xenbus_scanf(struct xenbus_transaction *t,
+int xenbus_scanf(xenbus_transaction_t t,
const char *dir, const char *node, const char *fmt, ...)
{
va_list ap;
EXPORT_SYMBOL(xenbus_scanf);
/* Single printf and write: returns -errno or 0. */
-int xenbus_printf(struct xenbus_transaction *t,
+int xenbus_printf(xenbus_transaction_t t,
const char *dir, const char *node, const char *fmt, ...)
{
va_list ap;
EXPORT_SYMBOL(xenbus_printf);
/* Takes tuples of names, scanf-style args, and void **, NULL terminated. */
-int xenbus_gather(struct xenbus_transaction *t, const char *dir, ...)
+int xenbus_gather(xenbus_transaction_t t, const char *dir, ...)
{
va_list ap;
const char *name;
void xenbus_unregister_driver(struct xenbus_driver *drv);
struct xenbus_transaction;
+typedef struct xenbus_transaction *xenbus_transaction_t;
-char **xenbus_directory(struct xenbus_transaction *t,
+char **xenbus_directory(xenbus_transaction_t t,
const char *dir, const char *node, unsigned int *num);
-void *xenbus_read(struct xenbus_transaction *t,
+void *xenbus_read(xenbus_transaction_t t,
const char *dir, const char *node, unsigned int *len);
-int xenbus_write(struct xenbus_transaction *t,
+int xenbus_write(xenbus_transaction_t t,
const char *dir, const char *node, const char *string);
-int xenbus_mkdir(struct xenbus_transaction *t,
+int xenbus_mkdir(xenbus_transaction_t t,
const char *dir, const char *node);
-int xenbus_exists(struct xenbus_transaction *t,
+int xenbus_exists(xenbus_transaction_t t,
const char *dir, const char *node);
-int xenbus_rm(struct xenbus_transaction *t, const char *dir, const char *node);
-struct xenbus_transaction *xenbus_transaction_start(void);
-int xenbus_transaction_end(struct xenbus_transaction *t, int abort);
+int xenbus_rm(xenbus_transaction_t t, const char *dir, const char *node);
+xenbus_transaction_t xenbus_transaction_start(void);
+int xenbus_transaction_end(xenbus_transaction_t t, int abort);
/* Single read and scanf: returns -errno or num scanned if > 0. */
-int xenbus_scanf(struct xenbus_transaction *t,
+int xenbus_scanf(xenbus_transaction_t t,
const char *dir, const char *node, const char *fmt, ...)
__attribute__((format(scanf, 4, 5)));
/* Single printf and write: returns -errno or 0. */
-int xenbus_printf(struct xenbus_transaction *t,
+int xenbus_printf(xenbus_transaction_t t,
const char *dir, const char *node, const char *fmt, ...)
__attribute__((format(printf, 4, 5)));
/* Generic read function: NULL-terminated triples of name,
* sprintf-style type string, and pointer. Returns 0 or errno.*/
-int xenbus_gather(struct xenbus_transaction *t, const char *dir, ...);
+int xenbus_gather(xenbus_transaction_t t, const char *dir, ...);
/* notifer routines for when the xenstore comes up */
int register_xenstore_notifier(struct notifier_block *nb);
* XenbusStateClosing, and the error will be saved in the store.
*/
int xenbus_switch_state(struct xenbus_device *dev,
- struct xenbus_transaction *xbt,
+ xenbus_transaction_t xbt,
XenbusState new_state);
static int parse_transaction_path(XsHandle *self, PyObject *args,
struct xs_handle **xh,
- struct xs_transaction_handle **th,
+ xs_transaction_handle *th,
char **path);
static PyObject *xspy_read(XsHandle *self, PyObject *args)
{
struct xs_handle *xh;
- struct xs_transaction_handle *th;
+ xs_transaction_handle th;
char *path;
char *xsval;
{
static char *arg_spec = "sss#";
struct xs_handle *xh = xshandle(self);
- struct xs_transaction_handle *th;
+ xs_transaction_handle th;
char *thstr;
char *path;
char *data;
if (!PyArg_ParseTuple(args, arg_spec, &thstr, &path, &data, &data_n))
return NULL;
- th = (struct xs_transaction_handle *)strtoul(thstr, NULL, 16);
+ th = (xs_transaction_handle)strtoul(thstr, NULL, 16);
Py_BEGIN_ALLOW_THREADS
result = xs_write(xh, th, path, data, data_n);
static PyObject *xspy_ls(XsHandle *self, PyObject *args)
{
struct xs_handle *xh;
- struct xs_transaction_handle *th;
+ xs_transaction_handle th;
char *path;
char **xsval;
static PyObject *xspy_mkdir(XsHandle *self, PyObject *args)
{
struct xs_handle *xh;
- struct xs_transaction_handle *th;
+ xs_transaction_handle th;
char *path;
bool result;
static PyObject *xspy_rm(XsHandle *self, PyObject *args)
{
struct xs_handle *xh;
- struct xs_transaction_handle *th;
+ xs_transaction_handle th;
char *path;
bool result;
unsigned int perms_n = 0;
int i;
- struct xs_transaction_handle *th;
+ xs_transaction_handle th;
char *thstr;
if (!xh)
if (!PyArg_ParseTuple(args, arg_spec, &thstr, &path))
return NULL;
- th = (struct xs_transaction_handle *)strtoul(thstr, NULL, 16);
+ th = (xs_transaction_handle)strtoul(thstr, NULL, 16);
Py_BEGIN_ALLOW_THREADS
perms = xs_get_permissions(xh, th, path, &perms_n);
int xsperms_n;
PyObject *tuple0 = NULL;
- struct xs_transaction_handle *th;
+ xs_transaction_handle th;
char *thstr;
if (!xh)
if (!PyArg_ParseTuple(args, "ssO", &thstr, &path, &perms))
goto exit;
- th = (struct xs_transaction_handle *)strtoul(thstr, NULL, 16);
+ th = (xs_transaction_handle)strtoul(thstr, NULL, 16);
if (!PyList_Check(perms)) {
PyErr_SetString(PyExc_RuntimeError, "perms must be a list");
static PyObject *xspy_transaction_start(XsHandle *self)
{
struct xs_handle *xh = xshandle(self);
- struct xs_transaction_handle *th;
+ xs_transaction_handle th;
char thstr[MAX_STRLEN(unsigned long) + 1];
if (!xh)
struct xs_handle *xh = xshandle(self);
bool result;
- struct xs_transaction_handle *th;
+ xs_transaction_handle th;
char *thstr;
if (!xh)
&thstr, &abort))
return NULL;
- th = (struct xs_transaction_handle *)strtoul(thstr, NULL, 16);
+ th = (xs_transaction_handle)strtoul(thstr, NULL, 16);
Py_BEGIN_ALLOW_THREADS
result = xs_transaction_end(xh, th, abort);
*/
static int parse_transaction_path(XsHandle *self, PyObject *args,
struct xs_handle **xh,
- struct xs_transaction_handle **th,
+ xs_transaction_handle *th,
char **path)
{
char *thstr;
if (!PyArg_ParseTuple(args, "ss", &thstr, path))
return 0;
- *th = (struct xs_transaction_handle *)strtoul(thstr, NULL, 16);
+ *th = (xs_transaction_handle)strtoul(thstr, NULL, 16);
return 1;
}
#if defined(CLIENT_rm)
static int
-do_rm(char *path, struct xs_handle *xsh, struct xs_transaction_handle *xth)
+do_rm(char *path, struct xs_handle *xsh, xs_transaction_handle xth)
{
if (xs_rm(xsh, xth, path)) {
return 0;
static int
perform(int optind, int argc, char **argv, struct xs_handle *xsh,
- struct xs_transaction_handle *xth, int prefix, int tidy)
+ xs_transaction_handle xth, int prefix, int tidy)
{
while (optind < argc) {
#if defined(CLIENT_read)
main(int argc, char **argv)
{
struct xs_handle *xsh;
- struct xs_transaction_handle *xth;
+ xs_transaction_handle xth;
int ret = 0, socket = 0;
int prefix = 0;
int tidy = 0;
}
/* Send message to xs, get malloc'ed reply. NULL and set errno on error. */
-static void *xs_talkv(struct xs_handle *h, struct xs_transaction_handle *t,
+static void *xs_talkv(struct xs_handle *h, xs_transaction_handle t,
enum xsd_sockmsg_type type,
const struct iovec *iovec,
unsigned int num_vecs,
}
/* Simplified version of xs_talkv: single message. */
-static void *xs_single(struct xs_handle *h, struct xs_transaction_handle *t,
+static void *xs_single(struct xs_handle *h, xs_transaction_handle t,
enum xsd_sockmsg_type type,
const char *string,
unsigned int *len)
return true;
}
-char **xs_directory(struct xs_handle *h, struct xs_transaction_handle *t,
+char **xs_directory(struct xs_handle *h, xs_transaction_handle t,
const char *path, unsigned int *num)
{
char *strings, *p, **ret;
* Returns a malloced value: call free() on it after use.
* len indicates length in bytes, not including the nul.
*/
-void *xs_read(struct xs_handle *h, struct xs_transaction_handle *t,
+void *xs_read(struct xs_handle *h, xs_transaction_handle t,
const char *path, unsigned int *len)
{
return xs_single(h, t, XS_READ, path, len);
/* Write the value of a single file.
* Returns false on failure.
*/
-bool xs_write(struct xs_handle *h, struct xs_transaction_handle *t,
+bool xs_write(struct xs_handle *h, xs_transaction_handle t,
const char *path, const void *data, unsigned int len)
{
struct iovec iovec[2];
/* Create a new directory.
* Returns false on failure, or success if it already exists.
*/
-bool xs_mkdir(struct xs_handle *h, struct xs_transaction_handle *t,
+bool xs_mkdir(struct xs_handle *h, xs_transaction_handle t,
const char *path)
{
return xs_bool(xs_single(h, t, XS_MKDIR, path, NULL));
/* Destroy a file or directory (directories must be empty).
* Returns false on failure, or success if it doesn't exist.
*/
-bool xs_rm(struct xs_handle *h, struct xs_transaction_handle *t,
+bool xs_rm(struct xs_handle *h, xs_transaction_handle t,
const char *path)
{
return xs_bool(xs_single(h, t, XS_RM, path, NULL));
* Returns malloced array, or NULL: call free() after use.
*/
struct xs_permissions *xs_get_permissions(struct xs_handle *h,
- struct xs_transaction_handle *t,
+ xs_transaction_handle t,
const char *path, unsigned int *num)
{
char *strings;
* Returns false on failure.
*/
bool xs_set_permissions(struct xs_handle *h,
- struct xs_transaction_handle *t,
+ xs_transaction_handle t,
const char *path,
struct xs_permissions *perms,
unsigned int num_perms)
* You can only have one transaction at any time.
* Returns NULL on failure.
*/
-struct xs_transaction_handle *xs_transaction_start(struct xs_handle *h)
+xs_transaction_handle xs_transaction_start(struct xs_handle *h)
{
char *id_str;
unsigned long id;
id = strtoul(id_str, NULL, 0);
free(id_str);
- return (struct xs_transaction_handle *)id;
+ return (xs_transaction_handle)id;
}
/* End a transaction.
* Returns false on failure, which indicates an error: transactions will
* not fail spuriously.
*/
-bool xs_transaction_end(struct xs_handle *h, struct xs_transaction_handle *t,
+bool xs_transaction_end(struct xs_handle *h, xs_transaction_handle t,
bool abort)
{
char abortstr[2];
struct xs_handle;
struct xs_transaction_handle;
+typedef struct xs_transaction_handle * xs_transaction_handle;
/* On failure, these routines set errno. */
* Returns a malloced array: call free() on it after use.
* Num indicates size.
*/
-char **xs_directory(struct xs_handle *h, struct xs_transaction_handle *t,
+char **xs_directory(struct xs_handle *h, xs_transaction_handle t,
const char *path, unsigned int *num);
/* Get the value of a single file, nul terminated.
* Returns a malloced value: call free() on it after use.
* len indicates length in bytes, not including terminator.
*/
-void *xs_read(struct xs_handle *h, struct xs_transaction_handle *t,
+void *xs_read(struct xs_handle *h, xs_transaction_handle t,
const char *path, unsigned int *len);
/* Write the value of a single file.
* Returns false on failure.
*/
-bool xs_write(struct xs_handle *h, struct xs_transaction_handle *t,
+bool xs_write(struct xs_handle *h, xs_transaction_handle t,
const char *path, const void *data, unsigned int len);
/* Create a new directory.
* Returns false on failure, or success if it already exists.
*/
-bool xs_mkdir(struct xs_handle *h, struct xs_transaction_handle *t,
+bool xs_mkdir(struct xs_handle *h, xs_transaction_handle t,
const char *path);
/* Destroy a file or directory (and children).
* Returns false on failure, or if it doesn't exist.
*/
-bool xs_rm(struct xs_handle *h, struct xs_transaction_handle *t,
+bool xs_rm(struct xs_handle *h, xs_transaction_handle t,
const char *path);
/* Get permissions of node (first element is owner, first perms is "other").
* Returns malloced array, or NULL: call free() after use.
*/
struct xs_permissions *xs_get_permissions(struct xs_handle *h,
- struct xs_transaction_handle *t,
+ xs_transaction_handle t,
const char *path, unsigned int *num);
/* Set permissions of node (must be owner).
* Returns false on failure.
*/
-bool xs_set_permissions(struct xs_handle *h, struct xs_transaction_handle *t,
+bool xs_set_permissions(struct xs_handle *h, xs_transaction_handle t,
const char *path, struct xs_permissions *perms,
unsigned int num_perms);
* You can only have one transaction at any time.
* Returns NULL on failure.
*/
-struct xs_transaction_handle *xs_transaction_start(struct xs_handle *h);
+xs_transaction_handle xs_transaction_start(struct xs_handle *h);
/* End a transaction.
* If abandon is true, transaction is discarded instead of committed.
* Returns false on failure: if errno == EAGAIN, you have to restart
* transaction.
*/
-bool xs_transaction_end(struct xs_handle *h, struct xs_transaction_handle *t,
+bool xs_transaction_end(struct xs_handle *h, xs_transaction_handle t,
bool abort);
/* Introduce a new domain.
#define XSTEST
static struct xs_handle *handles[10] = { NULL };
-static struct xs_transaction_handle *txh[10] = { XBT_NULL };
+static xs_transaction_handle txh[10] = { XBT_NULL };
static unsigned int timeout_ms = 500;
static bool timeout_suppressed = true;
projects / xen.git / commitdiff